﻿<h1>Built-in Generics</h1>

<p>
Currently (Go 1.13), Go doesn't support user-defined generic types,
and only supports generics for first-class citizen composite types.
We can use composite types to create infinite custom types by using
all kinds of first-class citizen types in Go.
</p>

<p>
This article will show type composition examples
and explain how to read these composited types.
</p>

<h3>Type Composition Examples</h3>

<div>

<p>
Type compositions in Go are designed very intuitive and easy to interpret.
It is hardly to get lost in understanding Go composite types,
even if for some very complex ones.
The following will list several type composition examples,
from simpler ones to more complex ones.
</p>

Let's view an simple composite type literal.

<pre class="line-numbers"><code class="language-go">[3][4]int
</code></pre>

<p>
When interpreting a composite type, we should look at it from left to right.
The <code>[3]</code> on the left in the above type literal indicates that
this type is an array type.
The whole right part following the <code>[4]int</code> is another array type,
which is the element type of the first array type.
The element type of the element type (an array type) of the first array type
is built-in type <code>int</code>.
The first array type can be viewed as a two-dimensional array type.
</p>

An example on using this two-dimensional array type.
<pre class="line-numbers"><code class="language-go">package main

import (
	"fmt"
)

func main() {
	matrix := [3][4]int{
		{1, 0, 0, 1},
		{0, 1, 0, 1},
		{0, 0, 1, 1},
	}

	matrix[1][1] = 3
	a := matrix[1] // type of a is [4]int
	fmt.Println(a) // [0 3 0 1]
}
</code></pre>

<p>
</p>

Similarly,
<ul>
<li>
	<code>[][]string</code> is a slice type whose element type is
	another slice type <code>[]string</code>.
</li>
<li>
	<code>**bool</code> is a pointer type whose base type is
	another pointer type <code>*bool</code>.
</li>
<li>
	<code>chan chan int</code> is a channel type whose element type is
	another channel type <code>chan int</code>.
</li>
<li>
	<code>map[int]map[int]string</code> is a map type whose element type is
	another map type <code>map[int]string</code>.
	The key types of the two map types are both <code>int</code>.
</li>
<li>
	<code>func(int32) func(int32)</code> is a function type whose only
	return result type is another function type <code>func(int32)</code>.
	The two function types both have only one input parameter
	with type <code>int32</code>.
</li>
</ul>

<p>
</p>

Let's view another type.

<pre class="line-numbers"><code class="language-go">chan *[16]byte
</code></pre>

<p>
The <code>chan</code> keyword at the left most indicates this type is a channel type.
The whole right part <code>*[16]byte</code>, which is a pointer type,
denotes the element type of this channel type.
The base type of the pointer type is <code>[16]byte</code>, which is an array type.
The element type of the array type is <code>byte</code>.
</p>

An example on using this channel type.
<pre class="line-numbers"><code class="language-go">package main

import (
	"fmt"
	"time"
	"crypto/rand"
)

func main() {
	c := make(chan *[16]byte)

	go func() {
		// Use two arrays to avoid data races.
		var dataA, dataB = new([16]byte), new([16]byte)
		for {
			_, err := rand.Read(dataA[:])
			if err != nil {
				close(c)
			} else {
				c <- dataA
				dataA, dataB = dataB, dataA
			}
		}
	}()

	for data := range c {
		fmt.Println((*data)[:])
		time.Sleep(time.Second / 2)
	}
}
</code></pre>

<p>
</p>

<p>
Similarly, type <code>map[string][]func(int) int</code> is a map type.
The key type of this map type is <code>string</code>.
The remaining right part <code>[]func(int) int</code> denotes
the element type of the map type.
The <code>[]</code> indicates the element type is a slice type,
whose element type is a function type <code>func(int) int</code>.
</p>

An example on using the just explained map type.

<pre class="line-numbers"><code class="language-go">package main

import "fmt"

func main() {
	addone := func(x int) int {return x + 1}
	square := func(x int) int {return x * x}
	double := func(x int) int {return x + x}

	transforms := map[string][]func(int) int {
		"inc,inc,inc": {addone, addone, addone},
		"sqr,inc,dbl": {square, addone, double},
		"dbl,sqr,sqr": {double, double, square},
	}

	for _, n := range []int{2, 3, 5, 7} {
		fmt.Println(">>>", n)
		for name, transfers := range transforms {
			result := n
			for _, xfer := range transfers {
				result = xfer(result)
			}
			fmt.Printf(" %v: %v \n", name, result)
		}
	}
}
</code></pre>

<p>
</p>

Below is a type which looks some complex.

<pre class="line-numbers"><code class="language-go">[]map[struct {
	a int
	b struct {
		x string
		y bool
	}
}]interface {
	Build([]byte, struct {x string; y bool}) error
	Update(dt float64)
	Destroy()
}
</code></pre>

<p>
Let's read it from left to right.
The starting <code>[]</code> at the left most indicates this type is a slice type.
The following <code>map</code> keyword shows the element type of the slice type is a map type.
The struct type denoted by the struct literal enclosed in the <code>[]</code> following
the <code>map</code> keyword is the key type of the map type.
The element type of the map type is an interface type which specifies three methods.
The key type, a struct type, has two fields,
one field <code>a</code> is of <code>int</code> type,
and the other field <code>b</code> is of another struct type
<code>struct {x string; y bool}</code>.
</p>

<p>
Please note that the second struct type is also used as one parameter type
of one method specified by the just mentioned interface type.
</p>

To get a better readability, we often decompose such a type
into multiple type declarations.
The type alias <code>T</code> declared in the following code
and the just explained type above denote the identical type.

<pre class="line-numbers"><code class="language-go">type B = struct {
	x string
	y bool
}

type K = struct {
	a int
	b B
}

type E = interface {
	Build([]byte, B) error
	Update(dt float64)
	Destroy()
}

type T = []map[K]E
</code></pre>

</div>

<h3>The Current Status of the Built-in Generic Functionalities in Go</h3>

<p>
Besides the built-in generics for composite types,
there are several built-in functions which also support generics.
Such as the built-in <code>len</code> function can be used to
get the length of values of arrays, slices, maps, strings and channels.
Generally, the functions in the <code>unsafe</code> standard package
are also viewed as built-in functions.
</p>

<p>
The fact that currently Go doesn't support generics for custom types and functions
really brings some inconveniences in Go programming sometimes.
For example, the types of the arguments and results of most functions in the
<code>math</code> standard package are <code>float64</code>.
When we want to use these functions on values of other kinds of numeric types,
we must first convert the values to <code>float64</code> values as arguments,
and we must convert the <code>float64</code> results back to the original
numeric types, which is not only inconvenient, but also is not efficient.
</p>

<p>
Luckily, many kinds of Go projects don't need custom general types and functions.
And the shortcomings caused by lacking of custom generics can be partially remedied
by the reflection functionalities provided in Go (at run time) and code generating (at compile time).
</p>

<h3>The Future of Generics in Go</h3>

<p>
Go language design and development team
<a href="https://research.swtch.com/go2017#generics">wouldn't mind supporting generics feature in Go</a>,
it is just that they <a href="https://github.com/golang/go/issues/15292">haven't found a generics solution</a>
which will keep Go simple and clean yet.
So, it is (very) possible that Go 2 will support custom generics.
Currently, there is <a href="https://go.googlesource.com/proposal/+/master/design/go2draft-contracts.md">a page for Go 2 draft designs</a>,
including a generics design draft. The draft is still in the early phase so the final implementation would be much different.
</p>


